1. Technical Field of the Invention
This invention relates to program debugging. More particularly, it relates to visualizing exception generation.
2. Background Art
Developing and debugging software is difficult, in part because most software code executes invisibly. While there are typically user-visible manifestations of software behavior, such as user interfaces, there is a great deal of processing that goes on behind the scenes that is not visible.
Tools that can help developers to visualize this “behind the scenes” processing can speed up the development process, as well as make it easier to find and fix defects and thereby improve quality.
Many programming languages provide an explicit “exception” construct as a way for code to handle unexpected or atypical conditions. One part of the code will “throw” an exception, while another part of the code (perhaps in a separate code module) will “catch” and “handle” the exception. Both Java and C++, for example, support exceptions (try/catch blocks, and the throw statement).
There are tools available today that make some aspects of program structure and behavior visible to developers. There are tools that perform static analysis of source code, for example, and generate class diagrams from code files. Such tools are limited in that they are not looking at the dynamic, run-time behavior of software but rather at its structure. There are tools that look explicitly at exceptions and how they propagate, but these tools are also based on static analysis of code, and not on run-time behavior.
Software debuggers are another class of tool that supports visualization of software. Debuggers are focused on run-time behavior, and can help to analyze exceptions (e.g., by setting breakpoints near throw or catch statements). Debuggers do not, however, provide tools for the visualization of the history of exceptions. Instead such debuggers focus on a single instance of an exception at a time. In some cases, a limited form of exception history might be maintained but it is usually nothing more than a simple count. In other cases, static propagation of exceptions focused on code path may be traced, there is no evaluation of classes of exceptions.